home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / comm / bbs / wwbbs31_source.lha / WWBBS / RxSrc / filebase_files.c < prev    next >
C/C++ Source or Header  |  1995-06-26  |  13KB  |  453 lines
  1. #include <exec/types.h>
  2. #include <exec/exec.h>
  3. #include <libraries/wwbbs.h>
  4. #include <ctype.h>
  5. #include <math.h>
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9.  
  10. #include <proto/dos.h>
  11. #include <proto/exec.h>
  12. #include <proto/rexxsyslib.h>
  13. #include <proto/wwbbs.h>
  14.  
  15. #include "rx.h"
  16.  
  17. #include "filebase.h"
  18.  
  19. void NextFile(BYTE *id)
  20.     {
  21.         BYTE user[33];
  22.         strcpy(user,"");
  23.         GetStatusTags(STTAG_Name,id,STTAG_UserName,user,TAG_END);
  24.         if(strlen(user))
  25.             {
  26.                 UBYTE accesslevel=0;
  27.                 if(GetUserTags(USRTAG_Name,user,USRTAG_AccessLevel,&accesslevel,TAG_END))
  28.                     {
  29.                         BOOL none=TRUE;
  30.                         if(strlen(file_area))
  31.                             {
  32.                                 APTR group;
  33.                                 if(group=OpenFileGroup(file_path,file_area,SHARED_LOCK))
  34.                                     {
  35.                                         ULONG num=0;
  36.                                         while(num=GetNextFile(group,file_current))
  37.                                             {
  38.                                                 none=FALSE;
  39.                                                 file_current=num;
  40.                                                 if(file_current>file_high)
  41.                                                     {
  42.                                                         file_high=file_current;
  43.                                                         SetFileGlobalHigh(file_global,file_group,file_high);
  44.                                                     }
  45.                                                 if(!DisplayFile(id,group))
  46.                                                     break;
  47.                                             }
  48.                                         CloseFileGroup(group);
  49.                                     }
  50.                             }
  51.                         if(none)
  52.                             {
  53.                                 BOOL kg=TRUE;
  54.                                 BYTE temp_path[256],temp_area[33];
  55.                                 ULONG temp_high=0;
  56.                                 BYTE accessrange[21];
  57.                                 BYTE group[41];
  58.                                 strcpy(temp_path,file_path);
  59.                                 strcpy(temp_area,file_area);
  60.                                 strcpy(accessrange,"");
  61.                                 strcpy(group,"");
  62.                                 printf("~s\n");
  63.                                 while(kg && GetNextArea(temp_path,temp_area))
  64.                                     {
  65.                                         if(GetConfigTags(CFGTAG_Path,temp_path,CFGTAG_Name,temp_area,FBTAG_AccessRange,accessrange,FBTAG_Group,group,TAG_END))
  66.                                             {
  67.                                                 if(IsRange(accessrange,accesslevel))
  68.                                                     {
  69.                                                         if(FindName(file_global,group))
  70.                                                             {
  71.                                                                 temp_high=GetFileGlobalHigh(file_global,group);
  72.                                                                 {
  73.                                                                     BOOL desc=FALSE;
  74.                                                                     APTR _group;
  75.                                                                     if(_group=OpenFileGroup(temp_path,temp_area,SHARED_LOCK))
  76.                                                                         {
  77.                                                                             if(GetNextFile(_group,temp_high))
  78.                                                                                 {
  79.                                                                                     strcpy(file_path,temp_path);
  80.                                                                                     strcpy(file_area,temp_area);
  81.                                                                                     strcpy(file_group,group);
  82.                                                                                     file_current=file_high=GetFileGlobalHigh(file_global,group);
  83.                                                                                     {
  84.                                                                                         char *p;
  85.                                                                                         if(p=strchr(file_path,'/'))
  86.                                                                                             {
  87.                                                                                                 p++;
  88.                                                                                                 sprintf(file_fullpath,"%s/%s",p,file_area);
  89.                                                                                             }
  90.                                                                                         else
  91.                                                                                             strcpy(file_fullpath,file_area);
  92.                                                                                     }
  93.                                                                                     desc=DisplayArea(id,_group);
  94.                                                                                     kg=FALSE;
  95.                                                                                 }
  96.                                                                             CloseFileGroup(_group);
  97.                                                                         }
  98.                                                                     if(desc)
  99.                                                                         GetFileDescriptions(id);
  100.                                                                 }
  101.                                                             }
  102.                                                     }
  103.                                             }
  104.                                     }
  105.                                 if(kg)
  106.                                     printf("End of global search.\n");
  107.                             }
  108.                     }
  109.             }
  110.     }
  111.  
  112. void CurrentFile(BYTE *id)
  113.     {
  114.         if(strlen(file_area))
  115.             {
  116.                 APTR group;
  117.                 if(group=OpenFileGroup(file_path,file_area,SHARED_LOCK))
  118.                     {
  119.                         if(file_current)
  120.                             DisplayFile(id,group);
  121.                         else
  122.                             printf("~s\nCurrent file does not exist.\n");
  123.                         CloseFileGroup(group);
  124.                     }
  125.             }
  126.         else
  127.             printf("~s\nPlease enter a file area first.\n");
  128.     }
  129.  
  130. void PreviousFile(BYTE *id)
  131.     {
  132.         if(strlen(file_area))
  133.             {
  134.                 APTR group;
  135.                 if(group=OpenFileGroup(file_path,file_area,SHARED_LOCK))
  136.                     {
  137.                         ULONG num=0;
  138.                         if(num=GetPreviousFile(group,file_current))
  139.                             {
  140.                                 file_current=num;
  141.                                 DisplayFile(id,group);
  142.                             }
  143.                         else
  144.                             printf("~s\nPrevious file does not exist.\n");
  145.                         CloseFileGroup(group);
  146.                     }
  147.             }
  148.         else
  149.             printf("~s\nPlease enter a file area first.\n");
  150.     }
  151.  
  152. void JumptoFile(BYTE *id)
  153.     {
  154.         if(strlen(file_area))
  155.             {
  156.                 APTR group;
  157.                 if(group=OpenFileGroup(file_path,file_area,SHARED_LOCK))
  158.                     {
  159.                         BYTE s[11];
  160.                         strcpy(s,"");
  161.                         printf("~p\nEnter number of file to jump to.\n: ");
  162.                         if(GetLine(s,10,GLFLG_Digits))
  163.                             {
  164.                                 if(GetFileTags(group,FILTAG_ID,atol(s),FILTAG_Exists,TRUE,TAG_END))
  165.                                     {
  166.                                         file_current=atol(s);
  167.                                         if(file_current>file_high)
  168.                                             {
  169.                                                 file_high=file_current;
  170.                                                 SetFileGlobalHigh(file_global,file_group,file_high);
  171.                                             }
  172.                                         DisplayFile(id,group);
  173.                                     }
  174.                                 else
  175.                                     {
  176.                                         ULONG num=0;
  177.                                         if(num=GetNextFile(group,atol(s)))
  178.                                             {
  179.                                                 file_current=num;
  180.                                                 if(file_current>file_high)
  181.                                                     {
  182.                                                         file_high=file_current;
  183.                                                         SetFileGlobalHigh(file_global,file_group,file_high);
  184.                                                     }
  185.                                                 DisplayFile(id,group);
  186.                                             }
  187.                                         else
  188.                                             printf("~s\nUnable to jump to file number %ld.\n",atol(s));
  189.                                     }
  190.                             }
  191.                         CloseFileGroup(group);
  192.                     }
  193.             }
  194.         else
  195.             printf("~s\nPlease enter a file area first.\n");
  196.     }
  197.  
  198. void ListFiles(BYTE *id)
  199.     {
  200.         BYTE rows[4];
  201.         strcpy(rows,"");
  202.         if(GetVar("ROWS",rows,3,NULL)!=-1)
  203.             {
  204.                 if(strlen(file_area))
  205.                     {
  206.                         ULONG lowfile=0,highfile=0;
  207.                         {
  208.                             APTR group;
  209.                             if(group=OpenFileGroup(file_path,file_area,SHARED_LOCK))
  210.                                 {
  211.                                     lowfile=GetNextFile(group,0);
  212.                                     highfile=GetPreviousFile(group,~0);
  213.                                     CloseFileGroup(group);
  214.                                 }
  215.                         }
  216.                         if(lowfile && highfile)
  217.                             {
  218.                                 BYTE buff[21];
  219.                                 strcpy(buff,"");
  220.                                 printf("~p\nEnter range of files to list, %ld-%ld, `All' to list all files,\nor `New' to list new files.\n: ",lowfile,highfile);
  221.                                 if(GetLine(buff,20,NULL))
  222.                                     {
  223.                                         if(!stricmp(buff,"ALL"))
  224.                                             sprintf(buff,"%ld-%ld",lowfile,highfile);
  225.                                         if(!stricmp(buff,"NEW"))
  226.                                             sprintf(buff,"%ld-%ld",file_high+1,highfile);
  227.                                         {
  228.                                             APTR group;
  229.                                             if(group=OpenFileGroup(file_path,file_area,SHARED_LOCK))
  230.                                                 {
  231.                                                     ULONG next=0;
  232.                                                     BOOL first=FALSE;
  233.                                                     int line=0;
  234.                                                     int numwidth;
  235.                                                     numwidth=(int) (log10((double) highfile)+1);
  236.                                                     if(numwidth<3) numwidth=3;
  237.                                                     while(next=GetNextFile(group,next))
  238.                                                         {
  239.                                                             if(IsRange(buff,next))
  240.                                                                 {
  241.                                                                     if(WaitForChar(Input(),0))
  242.                                                                         {
  243.                                                                             getchar();
  244.                                                                             break;
  245.                                                                         }
  246.                                                                     if(!first)
  247.                                                                         {
  248.                                                                             printf("\n~h%*sNum File             Size Description%*s\n~o",numwidth-3,"",42-(numwidth-3),"");
  249.                                                                             line++;
  250.                                                                             first=TRUE;
  251.                                                                         }
  252.                                                                     {
  253.                                                                         BYTE *file=NULL,*description=NULL;
  254.                                                                         ULONG size=0;
  255.                                                                         if(GetFileTags(group,FILTAG_ID,next,FILTAG_Name,&file,FILTAG_Size,&size,FILTAG_Description,&description,TAG_END))
  256.                                                                             {
  257.                                                                                 BYTE size_buff[5],description_buff[64];
  258.                                                                                 strcpy(size_buff,"");
  259.                                                                                 strcpy(description_buff,"");
  260.                                                                                 {
  261.                                                                                     strcpy(size_buff,"");
  262.                                                                                     if(size<1000*1024) /* 1 megabyte */
  263.                                                                                         sprintf(size_buff,"%dK",size/1024);
  264.                                                                                     else
  265.                                                                                         {
  266.                                                                                             if(size<10*1024*1024) /* 10 megabytes */
  267.                                                                                                 sprintf(size_buff,"%d.%dM",size/(1024*1024),((size%(1024*1024))*10)/(1024*1024));
  268.                                                                                             else
  269.                                                                                                 {
  270.                                                                                                     if(size<1000*1024*1024) /* 1 gigabyte */
  271.                                                                                                         sprintf(size_buff,"%dM",size/1024/1024);
  272.                                                                                                     else
  273.                                                                                                         strcpy(size_buff,"BIG");
  274.                                                                                                 }
  275.                                                                                         }
  276.                                                                                 }
  277.                                                                                 if(description)
  278.                                                                                     {
  279.                                                                                         BYTE *p;
  280.                                                                                         if(p=strchr(description,'\n'))
  281.                                                                                             {
  282.                                                                                                 if(p-description<64)
  283.                                                                                                     {
  284.                                                                                                         strncpy(description_buff,description,p-description);
  285.                                                                                                         description_buff[p-description]=NULL;
  286.                                                                                                     }
  287.                                                                                                 else
  288.                                                                                                     {
  289.                                                                                                         strncpy(description_buff,description,63);
  290.                                                                                                         description_buff[63]=NULL;
  291.                                                                                                     }
  292.                                                                                             }
  293.                                                                                         else
  294.                                                                                             {
  295.                                                                                                 if(strlen(description)<64)
  296.                                                                                                     strcpy(description_buff,description);
  297.                                                                                                 else
  298.                                                                                                     {
  299.                                                                                                         strncpy(description_buff,description,63);
  300.                                                                                                         description_buff[63]=NULL;
  301.                                                                                                     }
  302.                                                                                             }
  303.                                                                                     }
  304.                                                                                 else
  305.                                                                                     strcpy(description_buff,"");
  306.                                                                                 printf("%*d %-16.16s %4.4s %-*.*s\n",numwidth,next,file,size_buff,56-numwidth,56-numwidth,description_buff);
  307.                                                                                 line++;
  308.                                                                                 if(line==atoi(rows)-1)
  309.                                                                                     {
  310.                                                                                         printf("~pMore ([Y],N)? ");
  311.                                                                                         if(!Ask(NULL,TRUE))
  312.                                                                                             break;
  313.                                                                                         printf("~o");
  314.                                                                                         line=0;
  315.                                                                                     }
  316.                                                                             }
  317.                                                                     }
  318.                                                                 }
  319.                                                         }
  320.                                                     if(!first)
  321.                                                         printf("~s\nNo files found in specified range.\n");
  322.                                                     CloseFileGroup(group);
  323.                                                 }
  324.                                         }
  325.                                     }
  326.                             }
  327.                         else
  328.                             printf("~s\nNo files exist.\n");
  329.                     }
  330.                 else
  331.                     printf("~s\nPlease enter a file area first.\n");
  332.             }
  333.     }
  334.  
  335. void SearchNext(BYTE *id)
  336.     {
  337.         if(strlen(file_area))
  338.             {
  339.                 APTR group;
  340.                 if(group=OpenFileGroup(file_path,file_area,SHARED_LOCK))
  341.                     {
  342.                         BYTE parsed_filepattern[83],parsed_descriptionpattern[83],parsed_uploaderpattern[83];
  343.                         ULONG num=0;
  344.                         BYTE *file=NULL,*description=NULL,*uploader=NULL;
  345.                         ParsePatternNoCase((strlen(file_filepattern)) ? file_filepattern : "#?",parsed_filepattern,82);
  346.                         ParsePatternNoCase((strlen(file_descriptionpattern)) ? file_descriptionpattern : "#?",parsed_descriptionpattern,82);
  347.                         ParsePatternNoCase((strlen(file_uploaderpattern)) ? file_uploaderpattern : "#?",parsed_uploaderpattern,82);
  348.                         while(num=GetNextFile(group,file_current))
  349.                             {
  350.                                 file_current=num;
  351.                                 if(file_current>file_high)
  352.                                     {
  353.                                         file_high=file_current;
  354.                                         SetFileGlobalHigh(file_global,file_group,file_high);
  355.                                     }
  356.                                 if(GetFileTags(group,FILTAG_ID,file_current,FILTAG_Name,&file,FILTAG_Description,&description,FILTAG_Uploader,&uploader,TAG_END))
  357.                                     {
  358.                                         if(MatchPatternNoCase(parsed_filepattern,file) && MatchPatternNoCase(parsed_descriptionpattern,description) && MatchPatternNoCase(parsed_uploaderpattern,uploader))
  359.                                             {
  360.                                                 if(!DisplayFile(id,group))
  361.                                                     break;
  362.                                             }
  363.                                     }
  364.                             }
  365.                         CloseFileGroup(group);
  366.                     }
  367.             }
  368.         else
  369.             printf("~s\nPlease enter a file area first.\n");
  370.     }
  371.  
  372. void CatchupFiles(BYTE *id)
  373.     {
  374.         if(strlen(file_area))
  375.             {
  376.                 APTR group;
  377.                 if(group=OpenFileGroup(file_path,file_area,SHARED_LOCK))
  378.                     {
  379.                         if(Ask("Catchup files",FALSE))
  380.                             {
  381.                                 ULONG num=0;
  382.                                 if(num=GetPreviousFile(group,~0))
  383.                                     {
  384.                                         file_current=file_high=num;
  385.                                         SetFileGlobalHigh(file_global,file_group,file_high);
  386.                                         printf("~s\nAll files marked as read.\n");
  387.                                     }
  388.                                 else
  389.                                     printf("~s\nUnable to catch up files.\n");
  390.                             }
  391.                         CloseFileGroup(group);
  392.                     }
  393.             }
  394.         else
  395.             printf("~s\nPlease enter a file area first.\n");
  396.     }
  397.  
  398. BOOL DisplayFile(BYTE *id,APTR group)
  399.     {
  400.         BOOL ret=FALSE;
  401.         BYTE *name=NULL,*uploader=NULL;
  402.         ULONG size=0;
  403.         struct DateStamp *date=NULL;
  404.         UWORD downloads=0;
  405.         struct DateStamp *lastdownloaddate=NULL;
  406.         BYTE *description=NULL;
  407.         if(GetFileTags(group,FILTAG_ID,file_current,
  408.                 FILTAG_Name,&name,
  409.                 FILTAG_Uploader,&uploader,
  410.                 FILTAG_Size,&size,
  411.                 FILTAG_Date,&date,
  412.                 FILTAG_Downloads,&downloads,
  413.                 FILTAG_LastDownloadDate,&lastdownloaddate,
  414.                 FILTAG_Description,&description,
  415.                 TAG_END))
  416.             {
  417.                 printf("\n~h");
  418.                 {
  419.                     char date_buff[32];
  420.                     strcpy(date_buff,"");
  421.                     {
  422.                         struct DateTime dt;
  423.                         char time_buff[32];
  424.                         strcpy(time_buff,"");
  425.                         dt.dat_Stamp=*date;
  426.                         dt.dat_Format=FORMAT_USA;
  427.                         dt.dat_Flags=DTF_SUBST;
  428.                         dt.dat_StrDay=NULL;
  429.                         dt.dat_StrDate=date_buff;
  430.                         dt.dat_StrTime=time_buff;
  431.                         DateToStr(&dt);
  432.                         strcat(date_buff," ");
  433.                         strcat(date_buff,time_buff);
  434.                     }
  435.                     printf("[File     ] %-32s  %33.33s\n",name,date_buff);
  436.                 }
  437.                 printf("[Size     ] %-67ld\n",size);
  438.                 printf("[Uploader ] %-67s\n",uploader);
  439.                 {
  440.                     char buff[32];
  441.                     sprintf(buff,"[%ld/%ld]",file_current,GetPreviousFile(group,~0));
  442.                     printf("[Downloads] %-5d  %60.60s\n",downloads,buff);
  443.                 }
  444.                 if(description)
  445.                     {
  446.                         printf("\n");
  447.                         if(Pager(description,5))
  448.                             ret=TRUE;
  449.                     }
  450.             }
  451.         return(ret);
  452.     }
  453.